home *** CD-ROM | disk | FTP | other *** search
/ Graphics Plus / Graphics Plus.iso / msdos / fractal / frasr182 / targa.c < prev    next >
C/C++ Source or Header  |  1993-02-18  |  20KB  |  776 lines
  1. /** targa.c **/
  2.  
  3. #ifdef __TURBOC__
  4. #    pragma    warn -par
  5. #endif
  6.  
  7. #define TARGA_DATA
  8.  
  9. #include    <stdio.h>
  10. #include    <stdlib.h>
  11. #include    <string.h>
  12. #ifndef XFRACT
  13. #include    <conio.h>
  14. #endif
  15. #include    "targa.h"
  16. #include    "fractint.h"
  17. #include    "prototyp.h"
  18.  
  19.  
  20. /*************    ****************/
  21.  
  22. extern char far *mapdacbox;
  23.  
  24. /*************    ****************/
  25.  
  26. void    WriteTGA( int x, int y, int index );
  27. int    ReadTGA ( int x, int y );
  28. void    EndTGA    ( void );
  29. void    StartTGA( void );
  30. void    ReopenTGA( void );
  31.  
  32. /*************    ****************/
  33.  
  34. static unsigned _fastcall near Row16Calculate(unsigned,unsigned);
  35. static void    _fastcall near PutPix16(int,int,int);
  36. static unsigned _fastcall near GetPix16(int,int);
  37. static unsigned _fastcall near Row32Calculate(unsigned,unsigned);
  38. static void    _fastcall near PutPix32(int,int,int);
  39. static unsigned _fastcall near GetPix32(int,int);
  40. static void    _fastcall near DoFirstPixel(int,int,int);
  41. static void _fastcall fatalerror(char far *);
  42. static int  GetLine(int);
  43. static void _fastcall near SetDispReg(int,int);
  44. static int  VWait(void);
  45. static void _fastcall SetVBorder(int,int);
  46. static void _fastcall SetBorderColor(long);
  47. static void _fastcall SetVertShift(int);
  48. static void _fastcall SetInterlace(int);
  49. static void _fastcall SetBlndReg(int);
  50. static void _fastcall SetRGBorCV(int);
  51. static void _fastcall SetVCRorCamera(int);
  52. static void _fastcall SetMask(int);
  53. static void _fastcall SetBlndReg(int);
  54. static void _fastcall SetContrast(int);
  55. static void _fastcall SetHue(int);
  56. static void _fastcall SetSaturation(int);
  57. static void _fastcall SetHBorder(int,int);
  58. static void SetFixedRegisters(void);
  59. static void _fastcall VCenterDisplay(int);
  60. static void _fastcall SetOverscan(int);
  61. static void _fastcall near TSetMode(int);
  62. static int  GraphInit(void);
  63. static void GraphEnd(void);
  64.  
  65. /*************    ****************/
  66.  
  67. int         xorTARGA;
  68. unsigned far *tga16 = NULL;  /* [256] */
  69. long     far *tga32;         /* [256] */
  70. static int   last = 0;
  71.  
  72. /*************    ****************/
  73.  
  74. extern int    sxdots,sydots;        /* # of dots on the physical screen */
  75. static int    initialized;
  76.  
  77. /*************    ****************/
  78.  
  79. static void    (near _fastcall *DoPixel) ( int x, int y, int index );
  80. static void    (near _fastcall *PutPixel)( int x, int y, int index );
  81. static unsigned (near _fastcall *GetPixel)( int x, int y );
  82.  
  83. /**************************************************************************/
  84. #ifdef __BORLANDC__
  85. #if(__BORLANDC__ > 2)
  86.    #pragma warn -eff
  87. #endif
  88. #endif
  89.  
  90. static unsigned _fastcall near Row16Calculate( unsigned line, unsigned x1 )
  91. {
  92.     outp( DESTREG, (line >> 5) );
  93.     return( ((line & 31) << 10) | (x1 << 1) ); /* calc the pixel offset */
  94. }
  95.  
  96. /**************************************************************************/
  97.  
  98. static void _fastcall near PutPix16( int x, int y, int index )
  99. {
  100. unsigned far * ip;
  101.  
  102.     /**************/
  103.     ip = MK_FP( MEMSEG, Row16Calculate( y, x ) );
  104.     if( ! xorTARGA )
  105.         *ip = tga16[index];
  106.     else
  107.         *ip = *ip ^ 0x7fff;
  108. }
  109.  
  110. /**************************************************************************/
  111.  
  112. static unsigned _fastcall near GetPix16( int x, int y )
  113. {
  114. register unsigned pixel, index;
  115. unsigned far * ip;
  116.     /**************/
  117.     ip = MK_FP( MEMSEG, Row16Calculate( y, x ) );
  118.     pixel = *ip & 0x7FFF;
  119.     if( pixel == tga16[last] ) return( last );
  120.     for( index = 0; index < 256; index++ )
  121.         if( pixel == tga16[index] ) {
  122.             last = index;
  123.             return( index );
  124.         }
  125.     return( 0 );
  126. }
  127.  
  128. /**************************************************************************/
  129.  
  130. static unsigned _fastcall near Row32Calculate( unsigned line, unsigned x1 )
  131. {
  132.     outp( DESTREG, (line >> 4) );
  133.     return ( ((line & 15) << 11) | (x1 << 2) ); /* calc the pixel offset */
  134. }
  135.  
  136. /**************************************************************************/
  137.  
  138. static void _fastcall near PutPix32( int x, int y, int index )
  139. {
  140. long far * lp;
  141.     lp = MK_FP( MEMSEG, Row32Calculate( y, x ) );
  142.     if( ! xorTARGA )
  143.         *lp = tga32[index];
  144.     else
  145.         *lp = *lp ^ 0x00FFFFFF;
  146. }
  147.  
  148. /**************************************************************************/
  149.  
  150. static unsigned _fastcall near GetPix32( int x, int y )
  151. {
  152. register int index;
  153. long    pixel;
  154. long    far * lp;
  155.  
  156.     lp = MK_FP( MEMSEG, Row32Calculate( y, x ) );
  157.     pixel = *lp & 0x00FFFFFF;
  158.     if( pixel == tga32[last] ) return( last );
  159.     for( index = 0; index < 256; index++ )
  160.         if( pixel == tga32[index] ) {
  161.             last = index;
  162.             return( index );
  163.         }
  164.     return( 0 );
  165. }
  166.  
  167. /**************************************************************************/
  168.  
  169. static void _fastcall near DoFirstPixel( int x, int y, int index )
  170. {
  171. int cnt;
  172.     TSetMode( targa.mode | 1 );
  173.     for( cnt = 0; cnt < targa.MaxBanks; cnt += 2 ) { /* erase */
  174.         outp( DESTREG, cnt );
  175.         outp( SRCREG,  cnt + 1 );
  176.         erasesegment(targa.memloc,0);  /** general.asm **/
  177.     }
  178.     TSetMode( targa.mode & 0xFFFE );
  179.     PutPixel = DoPixel;
  180.     (*PutPixel)( x, y, index );
  181. }
  182.  
  183. #ifdef __BORLANDC__
  184. #if(__BORLANDC__ > 2)
  185.    #pragma warn +eff
  186. #endif
  187. #endif
  188.  
  189. /***************************************************************************/
  190.  
  191. void WriteTGA( int x, int y, int index )
  192. {
  193.     OUTPORTB(MODEREG, targa.mode |= 1 );    /* TSetMode inline for speed */
  194.     (*PutPixel)( x, sydots-y, index&0xFF ); /* fix origin to match EGA/VGA */
  195.     OUTPORTB(MODEREG, targa.mode &= 0xFFFE );
  196. }
  197.  
  198. /***************************************************************************/
  199.  
  200. int ReadTGA( int x, int y )
  201. {
  202. int val;
  203.     OUTPORTB(MODEREG, targa.mode |= 1 );    /* TSetMode inline for speed */
  204.     val = (*GetPixel)( x, sydots-y );
  205.     OUTPORTB(MODEREG, targa.mode &= 0xFFFE );
  206.     return( val );
  207. }
  208.  
  209. /***************************************************************************/
  210.  
  211. void EndTGA( void )
  212. {
  213.     if( initialized ) {
  214.         GraphEnd();
  215.         initialized = 0;
  216.     }
  217. }
  218.  
  219. /***************************************************************************/
  220.  
  221. void StartTGA()
  222. {
  223. int    i;
  224. static char far couldntfind[]={"Could not find Targa card"};
  225. static char far noenvvar[]={"TARGA environment variable missing"};
  226. static char far insuffmem[]={"Insufficient memory for Targa"};
  227.  
  228.     /****************/
  229.     if( initialized ) return;
  230.     initialized = 1;
  231.  
  232.     /****************/
  233.     /* note that video.asm has already set the regualar video adapter */
  234.     /* to text mode (ax in Targa table entries is 3);          */
  235.     /* that's necessary because TARGA can live at 0xA000, we DO NOT   */
  236.     /* want to have an EGA/VGA in graphics mode!!              */
  237.     ReopenTGA(); /* clear text screen and display message */
  238.  
  239.     /****************/
  240.     /*** look for and activate card ***/
  241.     if ((i = GraphInit()))
  242.         fatalerror((i == -1) ? couldntfind : noenvvar);
  243.  
  244.     VCenterDisplay( sydots + 1 );
  245.  
  246.     if (tga16 == NULL)
  247.         if ( (tga16 = (unsigned far *)farmemalloc(512L)) == NULL
  248.           || (tga32 = (long     far *)farmemalloc(1024L)) == NULL)
  249.         fatalerror(insuffmem);
  250.  
  251.     SetTgaColors();
  252.  
  253.     if( targa.boardType == 16 ) {
  254.         GetPixel = GetPix16;
  255.         DoPixel = PutPix16;
  256.     }
  257.     else {
  258.         GetPixel = GetPix32;
  259.         DoPixel = PutPix32;
  260.     }
  261.     PutPixel = DoFirstPixel;    /* on first pixel --> erase */
  262.  
  263.     if( sydots == 482 ) SetOverscan( 1 );
  264.  
  265.     TSetMode( targa.mode & 0xFFFE );
  266.  
  267.     /****************/
  268.     if (mapdacbox == NULL && SetColorPaletteName("default") != 0)
  269.         exit( 1 ); /* stopmsg has already been issued */
  270.  
  271. }
  272.  
  273. void ReopenTGA()
  274. {
  275. static char far runningontarga[]={"Running On TrueVision TARGA Card"};
  276.     helptitle();
  277.     putstring(2,20,7,runningontarga);
  278.     movecursor(6,0); /* in case of brutal exit */
  279. }
  280.  
  281. static void _fastcall fatalerror(char far *msg)
  282. {
  283. static char far abortmsg[]={"...aborting!"};
  284.     putstring(4,20,15,msg);
  285.     putstring(5,20,15,abortmsg);
  286.     movecursor(8,0);
  287.     exit(1);
  288. }
  289.  
  290.  
  291.  
  292. /***  the rest of this module used to be separate, in tgasubs.c,  ***/
  293. /***  has now been merged into a single source              ***/
  294.  
  295. /*******************************************************************/
  296.  
  297. static void _fastcall VCenterDisplay( int nLines )
  298. {
  299. int    lines;
  300. int top, bottom;
  301. long color;
  302.  
  303.     lines  = nLines >> 1;        /* half value of last line 0..x */
  304.     top    = 140 - (lines >> 1);
  305.     bottom = top + lines;
  306.     SetVBorder( top, bottom );
  307.     SetVertShift( 255 - lines );    /* skip lines we're not using */
  308.  
  309.     if( targa.boardType == 16 )
  310.         color = (12 << 10) | (12 << 5) | 12;
  311.     else
  312.         color = ((long)80 << 16) | (80 << 8) | 80;
  313.     SetBorderColor( color );
  314. }
  315.  
  316.  
  317. /*****************************************************************/
  318.  
  319. static void _fastcall near SetDispReg(int reg, int value)
  320. {
  321.     targa.DisplayRegister[reg] = value;
  322.  
  323.     TSetMode(targa.mode&MSK_REGWRITE);  /* select Index Register write */
  324.     OUTPORTB(DRREG, reg);    /* select sync register */
  325.     /*
  326.      *        Set Mask register to write value to
  327.      *        display register and to set Bit 9 in the DR
  328.      */
  329.     TSetMode( ((targa.mode|(~MSK_REGWRITE))     /* turn on write bit */
  330.                    & MSK_BIT9       )     /* turn off Bit 9 */
  331.                | ((value&0x0100)>>1)); /* set bit 9 for value */
  332.     OUTPORTB(DRREG, value); /* select sync register */
  333.  }
  334.  
  335. /*****************************************************************/
  336.  
  337. #define   WAITCOUNT  60000
  338.  
  339. static int VWait()
  340. {
  341. int    rasterreg;
  342. unsigned GiveUp;
  343.  
  344.     rasterreg = RASTERREG;
  345.  
  346.     /*
  347.      *    If beyond bottom of frame wait for next field
  348.      */
  349.     GiveUp= WAITCOUNT;
  350.     while ( (--GiveUp) && (GetLine(rasterreg) == 0) ) { }
  351.     if (GiveUp) {
  352.        /*
  353.         *       Wait for the bottom of the border
  354.         */
  355.        GiveUp= WAITCOUNT;
  356.        while ( (--GiveUp) && (GetLine(rasterreg) > 0) ) { }
  357.        }
  358.  
  359.     return ( ( GiveUp ) ? 0 : -1);
  360. }
  361.  
  362.  
  363. /*****************************************************************/
  364.  
  365. static void _fastcall SetVBorder(int top, int bottom)
  366. {
  367.     /* top border */
  368.     if ( top < MIN_TOP ) top=MIN_TOP;
  369.     SetDispReg(TOPBORDER,top);
  370.     /* bottom border */
  371.     if ( bottom > MAX_BOTTOM ) bottom=MAX_BOTTOM;
  372.     SetDispReg(BOTTOMBORDER,bottom);
  373.  
  374.     SetDispReg(DR10,top);
  375.     SetDispReg(DR11,bottom);
  376. }
  377.  
  378.  
  379. /*****************************************************************/
  380.  
  381. static void _fastcall SetRGBorCV(int type)
  382. {
  383.     /*  set the contrast level */
  384.     targa.RGBorCV = type;
  385.     targa.VCRCon = ( targa.VCRCon  & MSK_RGBORCV ) |
  386.                     (targa.RGBorCV<<SHF_RGBORCV) ;
  387.     OUTPORTB(VCRCON, targa.VCRCon );
  388. }
  389.  
  390. /*****************************************************************/
  391.  
  392. static void _fastcall SetVCRorCamera(int type)
  393. {
  394.     targa.VCRorCamera = type&1;
  395.     targa.VCRCon = ( targa.VCRCon  & MSK_VCRORCAMERA ) |
  396.                     (targa.VCRorCamera<<SHF_VCRORCAMERA) ;
  397.     OUTPORTB(VCRCON, targa.VCRCon );
  398. }
  399.  
  400.  
  401. /*****************************************************************/
  402.  
  403. static void _fastcall SetBorderColor(long color)
  404. {
  405.     targa.BorderColor = color;
  406.     OUTPORTB(BORDER, (int)(0x0000ffffL&(color)));
  407.     OUTPORTB((BORDER+2), (int)((color)>>16));
  408. }
  409.  
  410. /*****************************************************************/
  411.  
  412. static void _fastcall SetMask(int mask)
  413. {
  414.     /* mask to valid values and output to mode register */
  415.     targa.Mask = mask;
  416.     OUTPORTB(MASKREG, mask);
  417. }
  418.  
  419.  
  420. /*****************************************************************/
  421.  
  422. static void _fastcall SetVertShift(int preshift)
  423. {
  424.     /*  set the Vertical Preshift count  level */
  425.     targa.VertShift = preshift;
  426.     OUTPORTB(VERTPAN, preshift);
  427. }
  428.  
  429.  
  430. /*****************************************************************/
  431.  
  432. static void _fastcall SetOverscan(int mode)
  433. {
  434. long tempColor;
  435.  
  436.     targa.ovrscnOn = mode;
  437.     if ( mode == 0 ) {
  438.             INPORTB(UNDERREG);  /*    select underscan mode */
  439.             SetHBorder(    (DEF_LEFT+targa.xOffset),
  440.                         (DEF_RIGHT+targa.xOffset));
  441.             SetDispReg(4,352);
  442.             SetDispReg(5,1);
  443.             SetBorderColor(targa.BorderColor);
  444.     }
  445.     else    {
  446.             INPORTB(OVERREG);   /*    select overrscan mode */
  447.             SetDispReg(0,64);   /*    Set four of the display registers */
  448.             SetDispReg(1,363);  /*    to values required for Overscan */
  449.             SetDispReg(4,363);
  450.             SetDispReg(5,17);
  451.             tempColor = targa.BorderColor;
  452.             SetBorderColor(0L);
  453.             targa.BorderColor = tempColor;
  454.     }
  455. }
  456.  
  457.  
  458. /*****************************************************************/
  459.  
  460. static void _fastcall SetInterlace(int type)
  461. {
  462.     targa.InterlaceMode= type & MSK_INTERLACE;
  463.     SetDispReg(INTREG, targa.InterlaceMode);
  464.     /*
  465.      *    SET THE INTERLACE BIT TO MATCH THE INTERLACE MODE AND
  466.      *    SCREEN RESOLUTION -  SCREEN PAGE
  467.      */
  468.     if ( ( targa.InterlaceMode >= 2 ) &&
  469.          ( targa.PageMode> 1 )    &&
  470.          ( (targa.PageMode&1) != 0 )  )
  471.         TSetMode(targa.mode|(~MSK_IBIT) );
  472.     else
  473.         TSetMode(targa.mode& MSK_IBIT);
  474. }
  475.  
  476.  
  477. /*****************************************************************/
  478.  
  479. static void _fastcall SetBlndReg(int value)
  480. {
  481.     /*  set the Vertical Preshift count  level */
  482.     if ( targa.boardType == 32 ) {
  483.         targa.VCRCon = (targa.VCRCon&0xfe) | value;
  484.         OUTPORTB(BLNDREG, value);
  485.         }
  486. }
  487.  
  488.  
  489. /*****************************************************************/
  490.  
  491. static void _fastcall near TSetMode(int mode)
  492. {
  493.     /* mask to valid values and output to mode register */
  494.     OUTPORTB(MODEREG, mode );
  495.     targa.mode = mode;
  496. }
  497.  
  498.  
  499. /*****************************************************************/
  500.  
  501. static void _fastcall SetContrast(int level)
  502. {
  503.     /*  set the contrast level */
  504.     targa.Contrast = level &((~MSK_CONTRAST)>>SHF_CONTRAST);
  505.     targa.VCRCon = ( targa.VCRCon  & MSK_CONTRAST ) |
  506.             (targa.Contrast<<SHF_CONTRAST) ;
  507.     OUTPORTB(VCRCON, targa.VCRCon );
  508. }
  509.  
  510.  
  511. /*****************************************************************/
  512.  
  513. static void _fastcall SetHue(int level)
  514. {
  515.     /*  set the hue level -  Mask to valid value */
  516.     targa.Hue = level&((~MSK_HUE)>>SHF_HUE);
  517.     /* mask to valid range */
  518.     targa.SatHue = (targa.SatHue&MSK_HUE) | (targa.Hue<<SHF_HUE);
  519.     OUTPORTB(SATHUE, targa.SatHue );
  520. }
  521.  
  522.  
  523. /*****************************************************************/
  524.  
  525. static void _fastcall SetSaturation(int level)
  526. {
  527.     /*  set the saturation level */
  528.     targa.Saturation= level&( (~MSK_SATURATION)>>SHF_SATURATION);
  529.     targa.SatHue =    (targa.SatHue&MSK_SATURATION) |
  530.              (targa.Saturation<<SHF_SATURATION);
  531.     OUTPORTB(SATHUE , targa.SatHue );
  532. }
  533.  
  534.  
  535. /*************************************************************/
  536.  
  537. /*** UNUSED
  538. static void _fastcall SetPageMode(int pageMode)
  539. {
  540.     pageMode &= 0x07;
  541.     targa.PageMode = pageMode;
  542.     VWait();
  543.     TSetMode( (targa.mode)&(MSK_RES) |((pageMode<<SHF_RES)&(~MSK_RES)) ) ;
  544.     if ( ( targa.DisplayRegister[20] >= 2 ) &&
  545.          ( pageMode> 1 )  &&
  546.          ( (pageMode&1) != 0 )      )    TSetMode(targa.mode|(~MSK_IBIT) );
  547.     else
  548.         TSetMode(targa.mode& MSK_IBIT);
  549. }
  550. ***/
  551.  
  552.  
  553. /*****************************************************************/
  554.  
  555. static void _fastcall SetHBorder(int left, int right)
  556. {
  557.     SetDispReg(LEFTBORDER, left);    /* set horizontal left border */
  558.     SetDispReg(RIGHTBORDER,right);    /* set horizontal right border */
  559. /*
  560.  *                    Set DR 8 and 9 since they
  561.  *                    default to tracking DR0 and DR 1
  562.  */
  563.     SetDispReg(DR8,left);
  564.     SetDispReg(DR9,left);
  565. }
  566.  
  567.  
  568. /*****************************************************************/
  569.  
  570. /*** UNUSED
  571. static void _fastcall SetGenlock(int OnOrOff)
  572. {
  573.     TSetMode( (targa.mode)&(MSK_GENLOCK)
  574.             |((OnOrOff<<SHF_GENLOCK)&(~MSK_GENLOCK)) );
  575. }
  576. ***/
  577.  
  578.  
  579. /*****************************************************************/
  580. /* was asm, TC fast enough on AT */
  581.  
  582. static int GetLine( int port )
  583. {
  584. int cnt;
  585. int val1, val2;
  586.  
  587.     val1 = INPORTB( port );
  588.     for( cnt = 0; cnt < 20; cnt++ ) {
  589.         val2 = INPORTB( port );
  590.         if( val1 == val2 )
  591.             break;
  592.         val1 = val2;
  593.     }
  594.     return( val1 );
  595. }
  596.  
  597.  
  598. /**********************************************************************
  599.               TINIT
  600. **********************************************************************/
  601.  
  602. static int GraphInit()
  603. {
  604. int i;
  605. int bottom, top;
  606. char *envptr;
  607. unsigned switches, got_switches;
  608.  
  609.     memset( &targa, 0, sizeof(targa) );
  610.  
  611.     targa.boardType = TYPE_16;        /* default to T16 */
  612.     targa.xOffset = 0;  targa.yOffset = 0;    /* default to no offset */
  613.     targa.LinesPerField= DEF_ROWS/2;    /*  number of lines per field */
  614.     targa.AlwaysGenLock = DEF_GENLOCK;    /* default to genlock off */
  615.     targa.PageMode = 0;
  616.     targa.InterlaceMode = DEF_INT;        /* Defalut:  Interlace Mode 0 */
  617.     targa.Contrast= DEF_CONTRAST;
  618.     targa.Saturation = DEF_SATURATION;
  619.     targa.Hue = DEF_HUE;
  620.     targa.RGBorCV = CV;            /* default to Composite video */
  621.     targa.VCRorCamera = CAMERA;
  622.     targa.PanXOrig = 0; targa.PanYOrig=0;
  623.     targa.PageUpper= 0xffff;        /* set the bank flags to illega& values */
  624.     targa.PageLower= 0xffff;        /* so that they will be set the first time */
  625.     targa.ovrscnAvail = 0;            /* Assume no Overscan option */
  626.     targa.ovrscnOn = 0;
  627.  
  628.     if ((envptr = getenv("TARGA")) == NULL)
  629.        return(-2);
  630.     switches = got_switches = 0;
  631.     while (*envptr) {
  632.        if (*envptr != ' ') ++got_switches;
  633.        if (*envptr >= '2' && *envptr <= '8')
  634.           switches |= (1 << ('8' - *envptr));
  635.        ++envptr;
  636.        }
  637.     if (got_switches == 0) { /* all blanks, use default */
  638.        targa.memloc = (signed int)0xA000;
  639.        targa.iobase = 0x220;
  640.        }
  641.     else {
  642.        targa.memloc = 0x8000 + ((switches & 0x70) << 8);
  643.        targa.iobase = 0x200  + ((switches & 0x0f) << 4);
  644.        }
  645.  
  646.     if ((envptr = getenv("TARGASET"))) {
  647.        while(1) { /* parse next parameter */
  648.           while (*envptr == ' ' || *envptr == ',') ++envptr;
  649.           if (*envptr == 0) break;
  650.           if (*envptr >= 'a' && *envptr <= 'z') *envptr -= ('a'-'A');
  651.           i = atoi(envptr+1);
  652.           switch (*envptr) {
  653.          case 'T':
  654.             if (i == 16) targa.boardType = TYPE_16;
  655.             if (i == 24) targa.boardType = TYPE_24;
  656.             if (i == 32) targa.boardType = TYPE_32;
  657.             break;
  658.          /* case 'E' not done, meaning not clear */
  659.          case 'X':
  660.             targa.xOffset = i;
  661.             break;
  662.          case 'Y':
  663.             targa.yOffset = i;
  664.             break;
  665.          case 'I':
  666.             targa.InterlaceMode = i;
  667.             break;
  668.          /* case 'N' not done, I don't know how to handle it */
  669.          case 'R':
  670.             targa.RGBorCV = RGB;
  671.             break;
  672.          case 'B':
  673.             targa.VCRorCamera = CAMERA;
  674.             break;
  675.          case 'V':
  676.             targa.VCRorCamera = VCR;
  677.             break;
  678.          case 'G':
  679.             targa.AlwaysGenLock = 1;
  680.             break;
  681.          case 'C':
  682.             targa.Contrast = i * 31 / 100;
  683.             break;
  684.          case 'S':
  685.             targa.Saturation = i * 7 / 100;
  686.             break;
  687.          case 'H':
  688.             targa.Hue = i * 31 / 100;
  689.             break;
  690.          /* note: 'A' and 'O' defined but apply only to type M8 */
  691.          /* case 'P' not handled cause I don't know how */
  692.          }
  693.           while (*(++envptr) >= '0' && *envptr <= '9') { }
  694.           }
  695.        }
  696.  
  697.     if ( targa.boardType == TYPE_16 ) {
  698.         targa.MaxBanks = 16;
  699.         targa.BytesPerPixel = 2;
  700.     }
  701.     if ( targa.boardType == TYPE_24 ) {
  702.         targa.MaxBanks = 32;
  703.         targa.BytesPerPixel = 3;
  704.     }
  705.     if ( targa.boardType == TYPE_32 ) {
  706.         targa.MaxBanks = 32;
  707.         targa.BytesPerPixel = 4;
  708.     }
  709.  
  710.     /****** Compute # of rows per 32K bank    ********/
  711.     targa.RowsPerBank = 512/(targa.MaxBanks);
  712.     targa.AddressShift =  targa.MaxBanks>>4;
  713.  
  714.     /*    if initializing CVA:  set these before we quit    */
  715.     SetSaturation(targa.Saturation);
  716.     SetHue(targa.Hue);
  717.     SetContrast( targa.Contrast);
  718.  
  719.     /*    Set Genlock bit if always genlocked */
  720.     /*    Set before flipping and jerking screen */
  721.     TSetMode( (targa.AlwaysGenLock<<SHF_GENLOCK) | DEF_MODE);
  722.  
  723.     SetBlndReg(0);        /*  disable blend mode on TARGA 32 */
  724.  
  725.     SetInterlace(targa.InterlaceMode);
  726.     SetFixedRegisters();
  727.     SetOverscan( 0 );
  728.  
  729.     top    = 140 - (targa.LinesPerField / 2);
  730.     bottom = top + targa.LinesPerField;
  731.     SetVBorder(top,bottom);
  732.     SetVertShift(256-targa.LinesPerField);
  733.  
  734.     SetMask(DEF_MASK);
  735.     SetRGBorCV (targa.RGBorCV );
  736.     SetVCRorCamera(targa.VCRorCamera);
  737.  
  738.     /*    See if the raster register is working correctly and
  739.         return error flag if its not         */
  740.     return (( VWait() == -1) ? -1 : 0);
  741.  
  742. }
  743.  
  744.  
  745. /**************************************************************/
  746.  
  747. static void GraphEnd()
  748. {
  749.     TSetMode( (targa.mode)&MSK_MSEL );     /*  disable memory */
  750. }
  751.  
  752.  
  753. /**************************************************************/
  754. /* Set the registers which have required values */
  755.  
  756. #define FIXED_REGS    10
  757.  
  758. static int FixedRegs[] = {
  759.     DR6,DR7,DR12,DR13,DR14,DR15,DR16,DR17,DR18,DR19
  760. };
  761.  
  762. static int FixedValue[] = {
  763.     DEF_DR6,DEF_DR7,DEF_DR12,DEF_DR13,DEF_DR14,
  764.     DEF_DR15,DEF_DR16,DEF_DR17,DEF_DR18,DEF_DR19
  765. };
  766.  
  767. static void SetFixedRegisters()
  768. {
  769. int reg;
  770.  
  771.     for ( reg=0; reg<FIXED_REGS; reg++)
  772.         SetDispReg(FixedRegs[reg],FixedValue[reg]);
  773. }
  774.  
  775.  
  776.